package com.gitee.qdbp.general.common.api.settings.model;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Date;
import java.util.List;
import com.gitee.qdbp.general.common.enums.SensitiveLevel;
import com.gitee.qdbp.general.common.enums.SensitiveType;
import com.gitee.qdbp.general.common.enums.UsingState;

/**
 * 敏感词信息查询类
 *
 * @author zhh
 * @version 170802
 */
public class SensitiveWordWhere extends SensitiveWordBean {

    /** 版本序列号 **/
    private static final long serialVersionUID = 1L;

    /** 敏感词ID列表 **/
    private List<String> ids;

    /** 敏感词ID前模匹配条件 **/
    private String idStarts;

    /** 敏感词ID后模匹配条件 **/
    private String idEnds;

    /** 敏感词ID模糊查询条件 **/
    private String idLike;

    /** 租户编号空值/非空值查询 **/
    private Boolean tenantCodeIsNull;

    /** 租户编号前模匹配条件 **/
    private String tenantCodeStarts;

    /** 租户编号后模匹配条件 **/
    private String tenantCodeEnds;

    /** 租户编号模糊查询条件 **/
    private String tenantCodeLike;

    /** 敏感词类型(0.默认)空值/非空值查询 **/
    private Boolean typeIsNull;

    /** 敏感词类型(0.默认)列表 **/
    private List<SensitiveType> types;

    /** 敏感词空值/非空值查询 **/
    private Boolean wordIsNull;

    /** 敏感词前模匹配条件 **/
    private String wordStarts;

    /** 敏感词后模匹配条件 **/
    private String wordEnds;

    /** 敏感词模糊查询条件 **/
    private String wordLike;

    /** 敏感级别(1.禁止|2.警告)空值/非空值查询 **/
    private Boolean levelIsNull;

    /** 敏感级别(1.禁止|2.警告)列表 **/
    private List<SensitiveLevel> levels;

    /** 例外组合空值/非空值查询 **/
    private Boolean excludeListIsNull;

    /** 例外组合前模匹配条件 **/
    private String excludeListStarts;

    /** 例外组合后模匹配条件 **/
    private String excludeListEnds;

    /** 例外组合模糊查询条件 **/
    private String excludeListLike;

    /** 最小创建时间 **/
    private Date createTimeMin;

    /** 最大创建时间 **/
    private Date createTimeMax;

    /** 最小创建时间 **/
    private Date createTimeMinWithDay;

    /** 最大创建时间 **/
    private Date createTimeMaxWithDay;

    /** 启用状态(1.正常|2.未启用)空值/非空值查询 **/
    private Boolean usingStateIsNull;

    /** 启用状态(1.正常|2.未启用)列表 **/
    private List<UsingState> usingStates;


    /** 获取敏感词ID列表 **/
    public List<String> getIds() {
        return ids;
    }

    /** 设置敏感词ID列表 **/
    public void setIds(List<String> ids) {
        this.ids = ids;
    }

    /** 增加敏感词ID **/
    public void addId(String... ids) {
        if (this.ids == null) {
            this.ids = new ArrayList<>();
        }
        this.ids.addAll(Arrays.asList(ids));
    }

    /** 获取敏感词ID前模匹配条件 **/
    public String getIdStarts() {
        return idStarts;
    }

    /** 设置敏感词ID前模匹配条件 **/
    public void setIdStarts(String idStarts) {
        this.idStarts = idStarts;
    }

    /** 获取敏感词ID后模匹配条件 **/
    public String getIdEnds() {
        return idEnds;
    }

    /** 设置敏感词ID后模匹配条件 **/
    public void setIdEnds(String idEnds) {
        this.idEnds = idEnds;
    }

    /** 获取敏感词ID模糊查询条件 **/
    public String getIdLike() {
        return idLike;
    }

    /** 设置敏感词ID模糊查询条件 **/
    public void setIdLike(String idLike) {
        this.idLike = idLike;
    }

    /** 判断租户编号是否为空值查询(true:空值查询|false:非空值查询) **/
    public Boolean getTenantCodeIsNull() {
        return tenantCodeIsNull;
    }

    /** 设置租户编号空值查询(true:空值查询|false:非空值查询) **/
    public void setTenantCodeIsNull(Boolean tenantCodeIsNull) {
        this.tenantCodeIsNull = tenantCodeIsNull;
    }

    /** 获取租户编号前模匹配条件 **/
    public String getTenantCodeStarts() {
        return tenantCodeStarts;
    }

    /** 设置租户编号前模匹配条件 **/
    public void setTenantCodeStarts(String tenantCodeStarts) {
        this.tenantCodeStarts = tenantCodeStarts;
    }

    /** 获取租户编号后模匹配条件 **/
    public String getTenantCodeEnds() {
        return tenantCodeEnds;
    }

    /** 设置租户编号后模匹配条件 **/
    public void setTenantCodeEnds(String tenantCodeEnds) {
        this.tenantCodeEnds = tenantCodeEnds;
    }

    /** 获取租户编号模糊查询条件 **/
    public String getTenantCodeLike() {
        return tenantCodeLike;
    }

    /** 设置租户编号模糊查询条件 **/
    public void setTenantCodeLike(String tenantCodeLike) {
        this.tenantCodeLike = tenantCodeLike;
    }

    /** 判断敏感词类型(0.默认)是否为空值查询(true:空值查询|false:非空值查询) **/
    public Boolean getTypeIsNull() {
        return typeIsNull;
    }

    /**
     * 设置敏感词类型(0.默认)空值查询(true:空值查询|false:非空值查询)
     *
     * @param typeIsNull 敏感词类型(0.默认)空值查询
     * @deprecated 该字段为非空字段
     */
    @Deprecated
    public void setTypeIsNull(Boolean typeIsNull) {
        this.typeIsNull = typeIsNull;
    }

    /** 获取敏感词类型(0.默认)列表 **/
    public List<SensitiveType> getTypes() {
        return types;
    }

    /** 设置敏感词类型(0.默认)列表 **/
    public void setTypes(List<SensitiveType> types) {
        this.types = types;
    }

    /** 增加敏感词类型(0.默认) **/
    public void addType(SensitiveType... types) {
        if (this.types == null) {
            this.types = new ArrayList<>();
        }
        this.types.addAll(Arrays.asList(types));
    }

    /** 判断敏感词是否为空值查询(true:空值查询|false:非空值查询) **/
    public Boolean getWordIsNull() {
        return wordIsNull;
    }

    /**
     * 设置敏感词空值查询(true:空值查询|false:非空值查询)
     *
     * @param wordIsNull 敏感词空值查询
     * @deprecated 该字段为非空字段
     */
    @Deprecated
    public void setWordIsNull(Boolean wordIsNull) {
        this.wordIsNull = wordIsNull;
    }

    /** 获取敏感词前模匹配条件 **/
    public String getWordStarts() {
        return wordStarts;
    }

    /** 设置敏感词前模匹配条件 **/
    public void setWordStarts(String wordStarts) {
        this.wordStarts = wordStarts;
    }

    /** 获取敏感词后模匹配条件 **/
    public String getWordEnds() {
        return wordEnds;
    }

    /** 设置敏感词后模匹配条件 **/
    public void setWordEnds(String wordEnds) {
        this.wordEnds = wordEnds;
    }

    /** 获取敏感词模糊查询条件 **/
    public String getWordLike() {
        return wordLike;
    }

    /** 设置敏感词模糊查询条件 **/
    public void setWordLike(String wordLike) {
        this.wordLike = wordLike;
    }

    /** 判断敏感级别(1.禁止|2.警告)是否为空值查询(true:空值查询|false:非空值查询) **/
    public Boolean getLevelIsNull() {
        return levelIsNull;
    }

    /**
     * 设置敏感级别(1.禁止|2.警告)空值查询(true:空值查询|false:非空值查询)
     *
     * @param levelIsNull 敏感级别(1.禁止|2.警告)空值查询
     * @deprecated 该字段为非空字段
     */
    @Deprecated
    public void setLevelIsNull(Boolean levelIsNull) {
        this.levelIsNull = levelIsNull;
    }

    /** 获取敏感级别(1.禁止|2.警告)列表 **/
    public List<SensitiveLevel> getLevels() {
        return levels;
    }

    /** 设置敏感级别(1.禁止|2.警告)列表 **/
    public void setLevels(List<SensitiveLevel> levels) {
        this.levels = levels;
    }

    /** 增加敏感级别(1.禁止|2.警告) **/
    public void addLevel(SensitiveLevel... levels) {
        if (this.levels == null) {
            this.levels = new ArrayList<>();
        }
        this.levels.addAll(Arrays.asList(levels));
    }

    /** 判断例外组合是否为空值查询(true:空值查询|false:非空值查询) **/
    public Boolean getExcludeListIsNull() {
        return excludeListIsNull;
    }

    /** 设置例外组合空值查询(true:空值查询|false:非空值查询) **/
    public void setExcludeListIsNull(Boolean excludeListIsNull) {
        this.excludeListIsNull = excludeListIsNull;
    }

    /** 获取例外组合前模匹配条件 **/
    public String getExcludeListStarts() {
        return excludeListStarts;
    }

    /** 设置例外组合前模匹配条件 **/
    public void setExcludeListStarts(String excludeListStarts) {
        this.excludeListStarts = excludeListStarts;
    }

    /** 获取例外组合后模匹配条件 **/
    public String getExcludeListEnds() {
        return excludeListEnds;
    }

    /** 设置例外组合后模匹配条件 **/
    public void setExcludeListEnds(String excludeListEnds) {
        this.excludeListEnds = excludeListEnds;
    }

    /** 获取例外组合模糊查询条件 **/
    public String getExcludeListLike() {
        return excludeListLike;
    }

    /** 设置例外组合模糊查询条件 **/
    public void setExcludeListLike(String excludeListLike) {
        this.excludeListLike = excludeListLike;
    }

    /** 获取最小创建时间 **/
    public Date getCreateTimeMin() {
        return createTimeMin;
    }

    /** 设置最小创建时间 **/
    public void setCreateTimeMin(Date createTimeMin) {
        this.createTimeMin = createTimeMin;
    }

    /** 获取最大创建时间 **/
    public Date getCreateTimeMax() {
        return createTimeMax;
    }

    /** 设置最大创建时间 **/
    public void setCreateTimeMax(Date createTimeMax) {
        this.createTimeMax = createTimeMax;
    }

    /** 获取最小创建时间 **/
    public Date getCreateTimeMinWithDay() {
        return createTimeMinWithDay;
    }

    /** 设置最小创建时间 **/
    public void setCreateTimeMinWithDay(Date createTimeMinWithDay) {
        this.createTimeMinWithDay = createTimeMinWithDay;
    }

    /** 获取最大创建时间 **/
    public Date getCreateTimeMaxWithDay() {
        return createTimeMaxWithDay;
    }

    /** 设置最大创建时间 **/
    public void setCreateTimeMaxWithDay(Date createTimeMaxWithDay) {
        this.createTimeMaxWithDay = createTimeMaxWithDay;
    }

    /** 判断启用状态(1.正常|2.未启用)是否为空值查询(true:空值查询|false:非空值查询) **/
    public Boolean getUsingStateIsNull() {
        return usingStateIsNull;
    }

    /**
     * 设置启用状态(1.正常|2.未启用)空值查询(true:空值查询|false:非空值查询)
     *
     * @param usingStateIsNull 启用状态(1.正常|2.未启用)空值查询
     * @deprecated 该字段为非空字段
     */
    @Deprecated
    public void setUsingStateIsNull(Boolean usingStateIsNull) {
        this.usingStateIsNull = usingStateIsNull;
    }

    /** 获取启用状态(1.正常|2.未启用)列表 **/
    public List<UsingState> getUsingStates() {
        return usingStates;
    }

    /** 设置启用状态(1.正常|2.未启用)列表 **/
    public void setUsingStates(List<UsingState> usingStates) {
        this.usingStates = usingStates;
    }

    /** 增加启用状态(1.正常|2.未启用) **/
    public void addUsingState(UsingState... usingStates) {
        if (this.usingStates == null) {
            this.usingStates = new ArrayList<>();
        }
        this.usingStates.addAll(Arrays.asList(usingStates));
    }

}